Distributed shared memory (DSM) provides an abstraction that allows users to view a physically distributed memory of a distributed system as a virtual shared address space. DSM provides a convenience for programmers of distributed applications, reducing or eliminating the requirement to be aware of the distributed architecture of the system and the requirement to use a less intuitive form of communication on a distributed system via message passing. DSM also provides a means to directly port software written for non-distributed systems to work on distributed systems.
There are many forms of DSM algorithms and technologies, all of them sharing a fundamental architecture of being composed of distributed agents deployed on a plurality of clustered nodes, maintaining local data structures and memory segments, and using a communication protocol over a message passing layer to coordinate operations. Message traffic should be minimized for a given load of work, and of course memory coherency should be maintained.
File systems improve the efficiency of storage accesses by using caching methods to reduce disk accesses. In clustered (a.k.a. shared disk) file systems, which provide concurrent read and write access from multiple clustered computers to files stored in shared external storage devices, caches are maintained within each computer. In such an architecture cache coherency, namely the integrity of data stored in the distributed caches, is a major consideration. Generally, all users accessing the file system should be provided with a consistent and serialized view of the files, avoiding corruption of data. Specifically, a read made by a user U1 to block B that follows a write by a user U2 (which may be the same or another user) to B must return the value written by U2, if no other writes to B were made between the two accesses. In addition, writes to the same block must be sequenced, namely all users view the values written to block B in the order that they were applied. Several approaches have been suggested for achieving cache coherency. A prominent and common approach is the write-invalidate method, where a write operation to a block B invalidates all the copies of that block in other caches.
In existing clustered file systems the resolution for cache coherency is generally a file. As long as a file is not modified, the contents of the file in all caches is consistent. When a user writes to a file, the contents associated with this file is invalidated in all other caches, in order to ensure a coherent view for other users. If such invalidation did not occur other users may receive obsolete contents of that file, thus defying cache coherency. When users read from a file, immediately after it was modified, the contents associated with this file in the cache of the user that performed the write operation is typically written to disk, thus maintaining coherency of the data being read. However, as write operations become more frequent, this cache coherence method becomes significantly inefficient, as the probability of cache hits is substantially reduced. For high performance distributed systems that employ intensive concurrent read/write access patterns to shared files, existing methods for cache coherency within clustered file systems result in poor performance.